// 所有的牌局都是存在round.js中的；
// 通过接口设置、获取牌局；
// var CardPool = require('./../../util/cardPool.js');
var exp = module.exports;
var log = console.log;

var cardPoolObj = {};  // 牌池才需要存起来，过程不用存
var resultListObj = {};

var replaceCard = [];

// 获取牌点数
function getPoint(card) {
    return parseInt(card.substring(1));
}

// 返回真正的点数
function getRealPoint(point) {
    if (!point) {
        return 0;
    }
    return point > 9 ? 0 : point;
}

/**
 * 判断点数是否相同
 * player = {
 * 1: 'A3',  // 红桃3
 * 2: 'B5'	// 黑桃5
 * }
 */
function checkPlayerPair(player) {
    var num;
    var tmpNum;
    for (var k in player) {
        num = player[k].substring(1);
        if (!tmpNum) {
            tmpNum = num;
        }
        else {
            if (tmpNum !== num) {
                return false;
            }
        }
    }
    return true;
}

// 获取玩家的点数
function getCardsPoint(player) {
    var num = 0;
    var tmp = 0;
    for (var k in player) {
        tmp = getPoint(player[k]);
        // 如果点数大于9则记作0
        tmp = tmp > 9 ? 0 : tmp;
        num += tmp;
    }
    // 如果总点数大于9则只要个位数
    num = num > 9 ? num - 10 : num;
    return num;
}

// // 为一个房间初始化牌局
// function initCardPool(rid) {
//     var cardPool;
//     if (!cardPoolObj[rid]) {
//         cardPool = new CardPool().get(8);

//         // 这里修改cardPool

//         cardPoolObj[rid] = cardPool;
//         resultListObj[rid] = [];
//     }
//     return cardPoolObj[rid];
// }

// 随机排序
function randomSort() {
    return Math.random() > 0.5;
}

// 获取一副打乱排序的牌
// 这个不包括大小王
function getCards() {
    var cards = [
        'D13', 'D12', 'D11', 'D10', 'D9', 'D8', 'D7', 'D6', 'D5', 'D4', 'D3', 'D2', 'D1',
        'C13', 'C12', 'C11', 'C10', 'C9', 'C8', 'C7', 'C6', 'C5', 'C4', 'C3', 'C2', 'C1',
        'B13', 'B12', 'B11', 'B10', 'B9', 'B8', 'B7', 'B6', 'B5', 'B4', 'B3', 'B2', 'B1',
        'A13', 'A12', 'A11', 'A10', 'A9', 'A8', 'A7', 'A6', 'A5', 'A4', 'A3', 'A2', 'A1'];
    return cards.sort(randomSort).sort(randomSort);
}

// 获取牌池
function getCardPool(rid) {
    var cardPool = [];
    for (let i = 0; i < 8; i++) {
        cardPool = cardPool.concat(getCards());
    }

    if (!cardPoolObj[rid]) {
        cardPoolObj[rid] = cardPool;
    }

    // console.log('牌池：', cardPool.length, cardPool.toString());

    return cardPool;
}

// 一个牌局进行一轮
function next(rid) {

    var cardPool;

    // 初始化牌池信息，结果列表信息
    if (!cardPoolObj[rid]) {
        cardPool = getCardPool(rid);
    } else {
        cardPool = cardPoolObj[rid];
    }

    if (cardPool.length < 100) {
        // log('重新加牌！');
        // log(cardPool.length, cardPool.toString());
        cardPool = cardPool.concat(getCardPool(rid));
        cardPoolObj[rid] = cardPool;
        // log(cardPool.length, cardPool.toString());
    }

    if (!resultListObj[rid]) {
        resultListObj[rid] = [];
    }

    var player = {};
    var banker = {};
    var bankerPoints = 0;
    var playerPoints = 0;
    var roundEnd = false;
    var round = {
        player: player,
        banker: banker
    };

    var result = {
        winner: '',
        bankerPair: false,
        playerPair: false
    };

    function getCard() {
        return cardPool.shift();
    }

    // 发牌
    // 这里用新的牌顶替掉发的牌
    function pushCards() {
        round.player[1] = getCard();
        round.banker[1] = getCard();
        round.player[2] = getCard();
        round.banker[2] = getCard();

        if (replaceCard.length >= 4) {
            round.player[1] = replaceCard[0];
            round.banker[1] = replaceCard[1];
            round.player[2] = replaceCard[2];
            round.banker[2] = replaceCard[3];
        }

        // console.log('round');
        // console.log(round);

        result.bankerPair = checkPlayerPair(banker);
        result.playerPair = checkPlayerPair(player);
        // console.log(result);
    }

    // 获取结果
    function getRoundResult() {
        playerPoints = getCardsPoint(player);
        bankerPoints = getCardsPoint(banker);
        // log('getRoundResult: p:', playerPoints, 'b:', bankerPoints);
        checkNatural();  // 检查是不是都不能补牌

        if (!roundEnd) {  // 玩家补牌，检查庄家是否需要补牌
            // log('check if player get card!');
            if (playerPoints <= 5) {
                // 只有玩家的点数小于等于5才可以补牌，否则就到下一步
                player[3] = getCard();

                // 这里替换牌
                if (replaceCard.length >= 5) {
                    player[3] = replaceCard[4];
                }
            }
            checkPlayerCard();  // 检查庄家是否需要补牌
        }

        if (!roundEnd) {  // 庄家补牌，判断结果
            // log('banker get card!');
            // log('getRoundResult2: p:', playerPoints, 'b:', bankerPoints);
            if (bankerPoints <= 6) {
                // TODO: 考虑是否需要判断
                // 前面的checkPlayerCard() 已经过滤掉了庄不能补牌的情况
                // 因此只要庄这里的小于5都可以补牌
                banker[3] = getCard();

                // 这里替换牌
                if (replaceCard.length >= 6) {
                    banker[3] = replaceCard[5];
                }

                roundEnd = true;
                bankerPoints += getRealPoint(getPoint(banker[3]));
                bankerPoints = bankerPoints > 9 ? bankerPoints - 10 : bankerPoints;
            }
        }
        genResult();  // 最后一定要计算结果
        var tmpResult = Object.create(result);
        tmpResult = result;

        resultListObj[rid].push(tmpResult);
    }

    // 获取结果
    function genResult() {
        // if (playerPoints >= 8) {
        // 	result.playerNature = true;
        // }
        // if (bankerPoints >= 8) {
        // 	result.bankerNature = true;
        // }
        if (playerPoints > bankerPoints) {
            result.winner = 'player';
        }
        else if (playerPoints === bankerPoints) {
            result.winner = 'none';
        }
        else {
            result.winner = 'banker';
        }
    }

    // 检查玩家是否需要补牌，先不管庄家最终不得补牌的情况
    function checkNatural() {
        // 都不需要补牌的情况
        // if (playerPoints >= 6 && bankerPoints >= 7) {
        if ((playerPoints >= 6 && bankerPoints >= 7) || playerPoints >= 8 || bankerPoints >= 8) {
            // 只要玩家大于等于6，并且庄家大于等于7，就都不能补牌了，结束
            // 或者玩家或庄家是天王，也都不能补牌
            // 否则如果P9B3就会继续为庄家补牌
            roundEnd = true;
            genResult();
        }
    }

    // 检查庄家是否补牌
    // 检查玩家的牌来判断庄家是否需要补牌，此时玩家的牌是0-5，庄家的牌是0-6
    // 返回即定胜负的情况(庄家不能补牌的情况)
    // 用来锁定胜局，其它的是庄家需要补牌的情况
    // 有可能玩家不需要补牌，但是庄家需要补牌
    function checkPlayerCard() {
        var point, realPoint;
        if (player[3]) {
            // 玩家补牌的情况
            // 既然发牌了就需要重新计算玩家真正点数，而不是要结束才计算
            point = getPoint(player[3]);
            realPoint = getRealPoint(point);
            playerPoints += realPoint;
            playerPoints = playerPoints > 9 ? playerPoints - 10 : playerPoints;
        }
        else if (bankerPoints > 2) {
            // 玩家不补牌并且庄家也不能补牌的情况
            // 庄家大于2点且玩家没有补牌
            roundEnd = true;
            return;
        }
        // 剩下玩家补牌，判断庄家是否需要补牌的情况

        // 庄家不能补牌的情况，此时玩家已经补牌
        if (bankerPoints === 3 && point === 8) {
            // 庄家是3点且玩家第三张牌是8，不补牌
            roundEnd = true;
        }
        else if (bankerPoints === 4 && (point >= 8 || point === 1)) {
            // 庄家是4点且闲家第3张牌是1,8,9,10,11,12,13 (0,1,8,9)
            roundEnd = true;
        }
        else if (bankerPoints === 5 && (point >= 8 || point <= 3)) {
            // 庄家是5点且闲家第3张牌是0,1,2,3,8,9 (1,2,3 8,9,10,11,12,13)
            roundEnd = true;
        }
        else if (bankerPoints === 6 && (point < 6 || point > 7)) {
            // 庄家是6点且玩家第3张牌是不是6或7
            roundEnd = true;
        }

        // 如果结束，判断结果
        if (roundEnd) {
            // log('checkPlayerCard: p:', playerPoints, 'b:', bankerPoints);
            genResult();
        }
    }

    pushCards();
    getRoundResult();

    // var points = '闲' + playerPoints + '点,庄' + bankerPoints + '点,';
    var points = {
        player: playerPoints,
        banker: bankerPoints
    };

    result.bNature = points.banker > 7;
    result.pNature = points.player > 7;

    // 判断大小 小： 0， 大： 1
    if (round.player[3] || round.banker[3]) {
        result.type = 1;
    }
    else {
        result.type = 0;
    }

    return { round, result, points };
}

function getRltList(rid) {
    return resultListObj[rid];
}

// function getCardPool(rid) {
//     return cardPoolObj[rid];
// }

// 如果顶替，就一直顶替
function replaceCards(arr) {
    replaceCard = arr;
    // replaceCard = ['A2', 'A11', 'A5', 'A1'];
    return true;
}


// exp.initCardPool = initCardPool;
exp.next = next;
exp.getRltList = getRltList;
// exp.getCardPool = getCardPool;
exp.replaceCards = replaceCards;
